RT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<assert.h>

using namespace std;

using std::string;

class Solution {
public:
    string addStrings(string num1, string num2) {
        int i = num1.size() - 1;
        int j = num2.size() - 1;
        int flag = 0;
        static string ret;
        int judge = 0;

        while (i >= 0 && j >= 0)
        {
            judge = num1[i] - '0' + num2[j] - '0';
            if (flag == 1)
            {
                judge++;
                flag = 0;
            }

            if (judge > 9)
            {
                flag = 1;
                judge -= 10;
            }
            else
            {
                flag = 0;
            }

            ret += judge + '0';
            i--;
            j--;
        }

        while (i >= 0)
        {
            ret += num1[i];
            i--;
        }
        while (j >= 0)
        {
            ret += num2[j];
            j--;
        }
        reverse(ret.begin(), ret.end());
        return ret;
    }
};

void test1()
{
    string num1 = "456";
    string num2 = "77";
    Solution a;
    string ret = a.addStrings(num1, num2);
    //string a="";
    //a += '3';
    //a += '4';
    //ret = "134";
    cout << ret << endl;
}


////////////////////////////////////////////////////////////////////////////////////


class TEST
{
public:
    TEST()
        :_tmp(NULL)
    {
        ;
    }
    TEST operator=(const TEST& d)
    {
        _tmp = d._tmp;
    }
private:
    char* _tmp;
};

class mystring
{
public:
    mystring()
        :_str(new char[1])
    {
        _str[0]='\0';
    }

    //深拷贝
    mystring(const char* str)
        :_str(new char[strlen(str)+1])
    {
        strcpy(_str, str);
    }
    //d2=d         深拷贝赋值
    mystring& operator=(const mystring& s)
    {
        if (this == &s)
        {
            return *this;
        }
        else
        {
            //if (_str)
            //    delete[] _str;
            //char* _str = new char[strlen(d._str) + 1];
            //strcpy(_str, d._str);
            //return *this;
            //更优一点
            char* tmp= new char[strlen(s._str) + 1];
            strcpy(tmp, s._str);
            delete[] _str;
            return *this;
        }
    }
    ~mystring()
    {
        if (_str != NULL)
        {
            delete[] _str;
        }
    }

private:
    char* _str;
};

int main()
{
    mystring d1;
    
    return 0;
}

//namespace my
//{
//	// 先实现一个简单的string，只考虑资源管理深浅拷贝问题
//	// 暂且不考虑增删查改
//	class string
//	{
//	public:
//        //深拷贝构造
//		string(const char* str)
//			:_str(new char[strlen(str)+1])
//		{
//			strcpy(_str, str);
//		}
//
//		// s2(s1)  深拷贝构造
//		string(const string& s)
//			:_str(new char[strlen(s._str)+1])
//		{
//			strcpy(_str, s._str);
//		}
//
//		// s1 = s3  s1.operator=(&s1, s3)
//		// s1 = s1      
//        //深拷贝赋值
//		string& operator=(const string& s)
//		{
//			if (this != &s)
//			{
//			    //delete[] _str;
//				//_str = new char[strlen(s._str) + 1];
//				//strcpy(_str, s._str);
//                //下面的更优  防止因为new失败丢失数据
//				char* tmp = new char[strlen(s._str) + 1];
//				strcpy(tmp, s._str);
//				delete[] _str;
//				_str = tmp;
//			}
//			return *this;
//		}
//        //析构
//		~string()
//		{
//			if (_str)
//			{
//				delete[] _str;
//			}
//		}
//        
//		const char* c_str() const
//		{
//			return _str;
//		}
//
//		char& operator[](size_t pos)
//		{
//			assert(pos < strlen(_str));
//
//			return _str[pos];
//		}
//
//		size_t size()
//		{
//			return strlen(_str);
//		}
//
//	private:
//		char* _str;
//	};
//}

namespace my
{
	// string需要考虑完善的增删查改和使用的string
	class string
	{
	public:
		//我们提供全缺省的构造
		string(const char* str = "")
			: _size(strlen(str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// s2(s1)  深拷贝构造
		string(const string& s)
			:_size(strlen(s._str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
		}
		//赋值(深)
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* tmp = new char[s._capacity + 1];
				strcpy(tmp, s._str);
				delete[] _str;
				_str = tmp;
				_size = s._size;
				_capacity = s._capacity;
			}

			return *this;
		}

		~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
				_size = _capacity = 0;
			}
		}

		const char* c_str() const
		{
			return _str;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);

			return _str[pos];
		}

		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}

		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;

				_capacity = n;
			}
		}

		// 扩空间+初始化
		// 删除部分数据，保留前n个
		void resize(size_t n, char ch = '\0')
		{
			if (n < _size)
			{
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				if (n > _capacity)
				{
					reserve(n);
				}

				for (size_t i = _size; i < n; ++i)
				{
					_str[i] = ch;
				}
				_size = n;
				_str[_size] = '\0';
			}
		}

		void push_back(char ch)
		{
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		void append(const char* str)
		{
			size_t len = _size + strlen(str);
			if (len > _capacity)
			{
				reserve(len);
			}

			strcpy(_str + _size, str);
			_size = len;
		}

		void insert(size_t pos, const char* str);
		void earse(size_t pos, size_t len);
		//void find;

	private:
		char* _str;
		size_t _size;     // 有效字符个数
		size_t _capacity; // 实际存储有效字符的空间
	};

	bool operator<(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) < 0;
	}

	bool operator==(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) == 0;
	}

	bool operator<=(const string& s1, const string& s2)
	{
		return s1 < s2 || s1 == s2;
	}

	bool operator>(const string& s1, const string& s2)
	{
		return !(s1 <= s2);
	}

	bool operator>=(const string& s1, const string& s2)
	{
		return !(s1 < s2);
	}

	bool operator!=(const string& s1, const string& s2)
	{
		return !(s1 == s2);
	}



